package com.mt.repair.service.repairManagement.impl;

import com.mt.repair.dao.repairManagement.RepairEvaluateDao;

import com.mt.common.core.exception.BusinessException;
import com.mt.common.core.web.base.PageDTO;
import com.mt.common.core.web.base.PageResultDTO;
import com.mt.common.core.web.base.BaseEntity;
import com.mt.common.core.web.BaseService;
import com.mt.repair.service.repairManagement.RepairOrderService;
import com.mt.repair.utils.SensitiveWordUtil;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import com.mt.repair.entity.repairManagement.RepairEvaluate;
import com.mt.repair.service.repairManagement.RepairEvaluateService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;

@Service
@Transactional
public class RepairEvaluateServiceBean extends BaseService implements RepairEvaluateService {

    private static Logger logger = LogManager.getLogger();

    @Autowired
    private RepairEvaluateDao repairEvaluateDao;

    @Resource
    private RedisTemplate<String, List<RepairEvaluate>> redisTemplate;

    @Autowired
    StringRedisTemplate stringRedisTemplate;

    @Autowired
    private RepairOrderService repairOrderService;

    @Autowired
	private SensitiveWordUtil sensitiveWordUtil;
    /**
     * 根据分页参数查询维修评价集合
     *
     * @param pageDTO 分页条件
     */
    @Override
    public PageResultDTO findRepairEvaluates(PageDTO pageDTO) {
        pageDTO.setStartIndex((pageDTO.getCurrentPage() - 1) * pageDTO.getPageSize());
        //TODO:请在此校验参数的合法性
        this.validateFindRepairEvaluates(pageDTO);
        List<RepairEvaluate> repairEvaluateDTOS = this.repairEvaluateDao.findRepairEvaluates(pageDTO);
        Long totalCount = this.repairEvaluateDao.findRepairEvaluateTotalCount(pageDTO);

        PageResultDTO pageResultDTO = new PageResultDTO();
        pageResultDTO.setTotalCount(totalCount);
        pageResultDTO.setDatas(repairEvaluateDTOS);

        return pageResultDTO;
    }

    /**
     * 查询全部维修评价集合
     */
    @Override
    public List<RepairEvaluate> findAllRepairEvaluates() {
        return this.repairEvaluateDao.findAllRepairEvaluates();
    }

    /**
     * 查询所有维修评价集合(只提取ID 和 Name)
     */
    @Override
    public List<RepairEvaluate> findAllRepairEvaluatesWithIdName() {
        //TODO:请在此校验参数的合法性
        this.validateFindAllRepairEvaluatesWithIdName();
        return this.repairEvaluateDao.findAllRepairEvaluatesWithIdName();
    }

    /**
     * 根据名称查询维修评价集合(只提取ID 和 Name)
     *
     * @param repairEvaluateName 名称
     */
    @Override
    public List<RepairEvaluate> findRepairEvaluatesWithIdNameByName(String repairEvaluateName) {
        //TODO:请在此校验参数的合法性
        this.validateFindRepairEvaluatesWithIdNameByName(repairEvaluateName);
        //TODO:缓存取对应参数
        Set<String> keys = stringRedisTemplate.keys("searchData:RepairEvaluate_where_repairEvaluateName_" + repairEvaluateName);
        List<RepairEvaluate> repairEvaluates = new ArrayList<>();
        if (keys.isEmpty()) {
            repairEvaluates = this.repairEvaluateDao.findRepairEvaluatesWithIdNameByName(repairEvaluateName);
            redisTemplate.opsForValue().set("searchData:RepairEvaluate_where_repairEvaluateName_" + repairEvaluateName, repairEvaluates, 30, TimeUnit.DAYS);
        } else {
            repairEvaluates = redisTemplate.opsForValue().get("searchData:RepairEvaluate_where_repairEvaluateName_" + repairEvaluateName);
        }
        return repairEvaluates;
    }

    /**
     * 根据ID查询指定的维修评价(只提取ID 和 Name)
     *
     * @param repairEvaluateId Id
     */
    @Override
    public RepairEvaluate findRepairEvaluatesWithIdNameById(Long repairEvaluateId) {
        //TODO:请在此校验参数的合法性
        this.validateFindRepairEvaluatesWithIdNameById(repairEvaluateId);
        return this.repairEvaluateDao.findRepairEvaluatesWithIdNameById(repairEvaluateId);
    }

    /**
     * 根据ID查询指定的维修评价
     *
     * @param repairEvaluateId Id
     */
    @Override
    public RepairEvaluate findRepairEvaluate(Long repairEvaluateId) {
        //TODO:请在此校验参数的合法性
        this.validateFindRepairEvaluate(repairEvaluateId);
        return this.repairEvaluateDao.findRepairEvaluate(repairEvaluateId);
    }

    /**
     * 根据ID查询指定的维修评价(包含外键)
     *
     * @param repairEvaluateId Id
     */
    @Override
    public RepairEvaluate findRepairEvaluateWithForeignName(Long repairEvaluateId) {
        //TODO:请在此校验参数的合法性
        this.validateFindRepairEvaluateWithForeignName(repairEvaluateId);
        return this.repairEvaluateDao.findRepairEvaluateWithForeignName(repairEvaluateId);
    }

    /**
     * 新增维修评价
     *
     * @param repairEvaluate 实体对象
     */
    @Override
    public RepairEvaluate saveRepairEvaluate(RepairEvaluate repairEvaluate) {
        //TODO:请在此校验参数的合法性
        this.validateSaveRepairEvaluate(repairEvaluate);
        //TODO:填充公共参数
        this.setSavePulicColumns(repairEvaluate);

        //对内容脱敏
		repairEvaluate.setEvaluateContent(sensitiveWordUtil.replaceSensitiveWord(repairEvaluate.getEvaluateContent(),'*',SensitiveWordUtil.MinMatchTYpe));

		Long rows = this.repairEvaluateDao.saveRepairEvaluate(repairEvaluate);
        if (rows != 1) {
            String error = "新增保存维修评价出错，数据库应该返回1,但返回了 " + rows;
            throw new BusinessException(error);
        }
        repairOrderService.evaluate(repairEvaluate.getRepairOrderId());
        return repairEvaluate;
    }

    /**
     * 更新维修评价
     *
     * @param repairEvaluate 实体对象
     */
    @Override
    public RepairEvaluate updateRepairEvaluate(RepairEvaluate repairEvaluate) {
        //TODO:请在此校验参数的合法性
        this.validateUpdateRepairEvaluate(repairEvaluate);
        Long rows = this.repairEvaluateDao.updateRepairEvaluate(repairEvaluate);
        if (rows != 1) {
            String error = "修改保存维修评价出错，数据库应该返回1,但返回了 " + rows + ",数据可能被删除";
            throw new BusinessException(error);
        }
        return repairEvaluate;
    }

    /**
     * 根据ID删除维修评价
     *
     * @param repairEvaluateId ID
     */
    @Override
    public void deleteRepairEvaluate(Long repairEvaluateId) {
        //TODO:请在此校验参数的合法性
        this.validateDeleteRepairEvaluate(repairEvaluateId);

        //Map<Class<? extends BaseEntity>, EntityUsage> entityUsageMap = this.checkForeignEntity(RepairEvaluate.class, repairEvaluateId);
        //if (entityUsageMap != null && entityUsageMap.size() > 0) {
        //    StringBuilder errors = new StringBuilder();
        //    errors.append("计划删除的数据正在被以下数引用\n");
        //    for (EntityUsage entityUsage : entityUsageMap.values()) {
        //        errors.append("\t").append(entityUsage.getEntityLabel()).append("\n");
        //        for (Map.Entry<Long, String> entry : entityUsage.getUsageIdNames().entrySet()) {
        //            errors.append("\t\t").append(entry.getKey()).append("\t").append(entry.getValue()).append("\n");
        //        }
        //    }
        //    errors.append("，不能删除，请检查处理后再删除");
        //    throw new BusinessException(errors.toString());
        //}

        Long rows = this.repairEvaluateDao.deleteRepairEvaluate(repairEvaluateId);
        if (rows != 1) {
            String error = "删除维修评价出错，数据可能已经被删除";
            throw new BusinessException(error);
        }
    }

    //TODO:---------------验证-------------------

    private void validateFindRepairEvaluates(PageDTO pageDTO) {
        //TODO:请使用下面方法添加数据过滤条件
        //		pageDTO.addFilter("creatorId",this.getLoginUserId());
        //TODO:请完善数据校验规则和数据权限判断，如果有问题请抛出异常，参看下面validateUpdateRepairEvaluate()写法
    }

    private void validateFindRepairEvaluatesWithIdNameByName(String repairEvaluateName) {
        //TODO:请完善数据校验规则和数据权限判断，如果有问题请抛出异常，参看下面validateUpdateRepairEvaluate()写法
    }


    private void validateFindAllRepairEvaluatesWithIdName() {
        //TODO:请完善数据校验规则和数据权限判断，如果有问题请抛出异常，参看下面validateUpdateRepairEvaluate()写法
    }

    private void validateFindRepairEvaluatesWithIdNameById(Long repairEvaluateId) {
        //TODO:请完善数据校验规则和数据权限判断，如果有问题请抛出异常，参看下面validateUpdateRepairEvaluate()写法
    }

    private void validateFindRepairEvaluate(Long repairEvaluateId) {
        //TODO:请完善数据校验规则和数据权限判断，如果有问题请抛出异常，参看下面validateUpdateRepairEvaluate()写法
    }

    private void validateFindRepairEvaluateWithForeignName(Long repairEvaluateId) {
        //TODO:请完善数据校验规则和数据权限判断，如果有问题请抛出异常，参看下面validateUpdateRepairEvaluate()写法
    }

    private void validateSaveRepairEvaluate(RepairEvaluate repairEvaluate) {
        //不为空判断
        if (repairEvaluate.getEid() != null || repairEvaluate.getCreatorId() != null || repairEvaluate.getCreateDatetime() != null) {
            throw new BusinessException("非法请求");
        }
        //TODO:请完善数据校验规则和数据权限判断，如果有问题请抛出异常，参看下面validateUpdateRepairEvaluate()写法
    }

    private void validateUpdateRepairEvaluate(RepairEvaluate repairEvaluate) {
        //不为空判断
        if (repairEvaluate.getEid() == null) {
            throw new BusinessException("唯一标识不能为空");
        }
        //是否存在判断
        if (this.repairEvaluateDao.findRepairEvaluateTotalCount(PageDTO.create(RepairEvaluate.FIELD_ID, repairEvaluate.getEid())) == 0) {
            throw new BusinessException("修改的维修评价 " + repairEvaluate.getName() + " 不存在，修改失败，请重试或联系管理员");
        }
        //TODO:请完善数据校验规则和数据权限判断，如果有问题请抛出异常，参看下面validateUpdateRepairEvaluate()写法
    }

    private void validateDeleteRepairEvaluate(Long repairEvaluateId) {
        //TODO:请完善数据校验规则和数据权限判断，如果有问题请抛出异常，参看下面validateUpdateRepairEvaluate()写法
    }

    @Override
    public boolean canDownloadAttachment(String formName, Long id) {
        return true;
    }
}
